﻿#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

//二分查找
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int k = 0;
//	while (~scanf("%d", &k))
//	{
//		int left = 0;
//		int right = sizeof(arr) / sizeof(arr[0]) - 1;
//		while (left <= right)
//		{
//			int mid = (left + right) / 2;
//			if (arr[mid] < k)
//				left = mid + 1;
//			else if (arr[mid] > k)
//				right = mid - 1;
//			else if (arr[mid] == k)
//			{
//				printf("找到了%d", mid);
//				break;
//
//			}
//		}
//		if (left > right)
//			printf("找不到\n");
//		
//	}
//	return 0;
//}
//
//
//假设我们计算某年某⽉有多少天？，如果要函数实现，可以设计2个函数: ?
//• is_leap_year()：根据年份确定是否是闰年 ?
//• get_days_of_month()：调⽤is_leap_year确定是否是闰年后，再根据⽉计算这个⽉的天数 ?
//int is_leap_year(int y)
//{
//	if (y % 4 && y % 100 != 0 || y % 400 == 0)
//		return 1;
//	else
//		return 0;
//}
//int get_days_of_month(int y, int m)
//{
//	int days[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
//	int day = days[m];
//	if (is_leap_year(y)&& m == 2)
//	{
//		day += 1;
//	}
//	return day;
//}
//int main()
//{
//
//	int y = 0;
//	int m = 0;
//	scanf("%d %d", &y, &m);
//	int ret = get_days_of_month(y, m);
//	printf("%d\n", ret);
//	return 0;
//}
//
//int main()
//{
//	printf("%d", printf("%d", printf("%d", 43)));
//	return 0;
//}
// 
// 
// 
//我们知道n的阶乘的公式： ? ? n！ = n ∗(n − 1)!
//4!=4*3!
//int Fait(int n)
//{
//	if (n <= 1)
//		return 1;
//	else
//		return n * Fait(n - 1);
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = Fait(n);
//	printf("%d\n", ret);
//	return 0;
//
//}

//// 迭代
//int  Fait(int n)
//{
//	int sum = 1;
//	for (int i = 1; i <= n; i++)
//	{
//		sum *= i;
//	}
//	return sum;
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = Fait(n);
//	printf("%d\n", ret);
//	return 0;
//}
//
//举例2：顺序打印⼀个整数的每⼀位 ?
//输⼊⼀个整数m，打印这个按照顺序打印整数的每⼀位。

//1234=1 2 3 4

//Fait(123)===Fait(12)+printf(3)
//Fait(1)+printf(2)+printf(3)
//void Fait(int n)
//{
//	if (n > 9)//12
//	Fait(n/10);
//		printf("%d ", n % 10);
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//     Fait(n);
//	return 0;
//}

//求第n个斐波那契数 ?
//1 1 2 3 5 ....
//int Fib(int n)
//{
//	if (n >= 3)
//		return Fib(n - 1) + Fib(n - 2);
//	else
//		return 1;
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = Fib(n);
//	printf("%d\n", ret);
//
//	return 0;
//}

//迭代的方法

//  
//int Fib(int n)
//{
//	int a = 1;
//	int b = 1;
//	int c = a + b;
//	while (n >= 3)
//	{
//		a = b;
//		b = c;
//		c = a + b;
//		n--;
//	}
//	
//	return b;
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = Fib(n);
////	printf("%d\n", ret);
////
////	return 0;
//}
////0.........1010
////
//int main()
//{
//	int num = -5;
//	int n = num >> 1;
//	printf("n= %d\n", n);
//	printf("num= %d\n", num);
//	return 0;
//}
//// 
//int main()
//{
//	int num = -3;
//	int n = ~num;
//	printf("n= %d\n", n);
//	printf("num= %d\n", num);
//	return 0;
//}

//练习1：编写代码实现：求⼀个整数存储在内存中的⼆进制中1的个数。


//int main()
//{
//	unsigned int n = 0;
//	while (~scanf("%d", &n))	//0......1010
//	{
//		int count = 0;
//
//		while (n)
//		{
//			if (n % 2 == 1)
//				count++;
//			n /= 2;
//		}
//		printf("%d\n", count);
//	}
//	return 0;
//}

//int main()
//{
//	 int n = 0;
//	while (~scanf("%d", &n))	//0......1010
//	{
//		int count = 0;
//		for (int i = 0; i < 32; i++)
//		{
//			if ((n >> i & 1) == 1)
//			{
//				count++;
//			}
//		}
//		printf("%d\n", count);
//		
//	}
//	return 0;
//}

//
//int main()
//{
//	int n = 0;
//	while (~scanf("%d", &n))	//0......1010
//	{
//		int count = 0;
//		while (n)
//		{
//			n = n & (n - 1);
//		
//			count++;
//		}
//		printf("%d\n", count);
//
//	}
//	return 0;
//}

//11.1 整型提升

//补充： char 无符号的unsigned char 的范围是0~255  char是-127——125
//int main()
//{
//	char c1 = 125;
//	char c2 = 10;
//	char c3 = c1 + c2;
//  //00000000000000000000000001111101-c1
//  // +
//  //00000000000000000000000000001010-C2
////截断：c1 01111101 有符号的
//	// c2 00001010 有符号的
//	//因为c1和c2都是占8bit位所有要发生截断
//
//
//	// 提升因为c3是有符号的类型存储不了必须截断
////00000000000000000000000001111101--C1
////00000000000000000000000000001010-C2
////00000000000000000000000010000111-C3
////截断10000111 -----C3
////11111111111111111111111110000111-----3补码
////10000000000000000000000001111001--原码
////
//	printf("%d\n", c3);
//
//	return 0;
//}、



//int main()
//{
//	char c1 = 125;
//	char c2 = 10;
//	//00000000000000000000000001111101-c1
//	// +
//	//00000000000000000000000000001010-C2
//  //截断：c1 01111101 有符号的
//	  // c2 00001010 有符号的
//	  //因为c1和c2都是占8bit位所有要发生截断
//
//
//  //00000000000000000000000001111101--C1
//  //00000000000000000000000000001010-C2
//  //00000000000000000000000010000111--  
//  //+ 因为不存在其他变量里所有不必要发生截断
//
//	printf("%d\n", c2+c1);
//
//	return 0;
//}

//const 修饰的变量
//int main()
//{
//	int a = 10;
//
//	int b = 10;
//	/*const int* p = &a;*/
//	*p = 20; 控制的是*p 对p=&b没有影响
//	p= &b;
//	 int* const p = &a; /* p = &b; 控制的是 p, 对*p = 20没有影响*/
//	 
//	return 0;
//}
 
////指针+指针
//
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int* pa = arr;
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", *(pa + i));
//	}
//	return 0;
////}
//
////指针-指针
//
//int main()
//{
//	char str[10] = "adwsf";
//	char* s1 = str;
//	char* strat = s1;
//	while (*s1!='\0')
//	{
//		s1++;
//	}
//	printf("%d\n", s1 - strat);
//	return 0;
//}


////模拟实现strlen
//int main()
//{
//	char str[10] = "adwsf";
//	char* s1 = str;
//	int count = 0;
//	while (*s1)
//	{
//		count++;
//		s1++;
//	}
//	printf("%d\n", count);
//	return 0;
//}

// assert断言
//#include <assert.h>
//int main()
//{
//	int a = 10;
//	int* p = &a;
//	assert(p != NULL);
//	return 0;
//}\

//学习指针的⽬的是使⽤指针解决问题，那什么问题，⾮指针不可呢？
//例如：写⼀个函数，交换两个整型变量的值
//void swap(int a, int b)
//{
//	a = a ^ b;
//	b = a ^ b;
//	a = a ^ b;
//}
//int main()
//{
//	int a=0;
//	int b = 0;
//	while (~scanf("%d %d", &a, &b))
//	{
//		swap(a, b);
//		printf("a=%d,b=%d\n", a, b);
//	}
//	return 0;
//}


//显然没有交换

//因为形参和实现开辟不同的内存空间 地址不同。
//void swap(int* a, int* b)
//{
//	*a = *a ^ *b;
//	*b = *a ^ *b;
//	*a = *a ^ *b;
//}
//int main()
//{
//	int a = 0;
//	int b = 0;
//	while (~scanf("%d %d", &a, &b))
//	{
//		swap(&a, &b);
//		printf("a=%d,b=%d\n", a, b);
////	}
////	return 0;
////}
////
//
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	printf("&arr[0] = %p\n", &arr[0]);
//	printf("&arr[0]+1 = %p\n", &arr[0] + 1);
//	printf("arr = %p\n", arr);
//	printf("arr+1 = %p\n", arr + 1);
//	printf("&arr = %p\n", &arr);
//	printf("&arr+1 = %p\n", &arr + 1);
//
//	return 0;
//}


//使⽤指针访问数组 ?
//
//int  main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int *p = arr;
//	for (int i = 0; i < 10; i++)
//	{
//		printf("%d ", p[i]);
//	}
//	return 0;
//}

//数组指针来实现数组打印
//
//int main()
//{
//	int arr[4] = { 1,2,343,54 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int(*pa)[4] = &arr;
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", *(*pa + i));
//   }
//	return 0;
//}

// 数组指针实现二维数组
//int main()
//{
//	int arr[2][2] = { {1,2},{2,3} };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int(*pa)[2] = &arr;
//	for (int i = 0; i < sz; i++)
//	{
//		for(int j=0;j<sz;j++ )
//		{
//			printf("%d ", pa[i][j]);
//		}
//		printf("\n");
//   }
//	return 0;
//}

//  指针数组

//int main()
//{
//	int a[2] = { 1,2 };
//	int b[2] = { 2,3 };
//	int* pa[2] = { a,b };
//	for (int i = 0; i < 2; i++)
//	{
//		for (int j = 0; j <2; j++)	
//		{
//			printf("%d ", pa[i][j]);
//		}
//		printf("\n");
//	}
//	return 0;
//}

////冒泡排序
//void bubble_sort(int arr[], int sz)
//{
//	int i = 0;
//	//一趟的冒泡排序
//	for (i = 0; i < sz - 1; i++)
//	{
//		//每趟排几次，比几次
//		int flag = 1;//假设是已经有续
//
//		for (int j = 0; j < sz - 1 - i; j++)
//		{
//			//交换//升序
//			if (arr[j] > arr[j + 1])
//			{
//				arr[j] ^= arr[j + 1];
//				arr[j + 1] ^= arr[j];
//				arr[j] ^= arr[j+1];
//				flag = 0;
//			}
//
//		}
//		if (flag == 1)
//		{
//			break;
//		}
//	}
//}
//int main()
//{ 
//	int arr[10] = { 1,354,56,36,8,23,6,34,62 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	bubble_sort(arr, sz);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}
//
//
//int main()
//{
//	int a[] = { 1,2,3 };
//	int(*pa)[2] = &a;
//	return 0;
////}
//
//
//int main()
//{
//	int a[] = { 1,2,3,4 };
//	int sz = sizeof(a) / sizeof(a[0]);
//	int(*pa)[4] = &a;
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", *(*pa + i));
//	}
//	return 0;
//}

// 数组指针模拟二维数组
//void Print(int(*pa)[2], int r, int c)
//{
//	for (int i = 0; i < r; i++)
//	{
//		for (int j = 0; j < c; j++)
//		{
//			printf("%d ", pa[i][j]);
//		}
//		printf("\n");
//	}
//}
//int main()
//{
//	int a[2][2] = { 1,2,3,4 };
//	int(*pa)[2] = &a;
//
//	printf("%d\n", *pa + 1);
//	printf("%d\n", *pa + 2);
//
//	return 0;
//}

//int  main()
//{
//	int a[10] = { 0,1,2,3,4,5,6,7,8,9};
//	int* p = a;
////	//p = a + 2;
////
////	printf("%d\n", *(p++));
////
////	return 0;
////}
//
//// 函数指针
//int Add(int x, int y)
//{
//	return x + y;
//}
//int main()
//{
//	int(*pf)(int, int) = Add;
//	int ret = pf(2, 3);
//	printf("%d\n", ret);
//	return 0;
//}
//
//int Add(int x, int y)
//{
//	return x + y;
//}
////转移表
//void call(int (*pf)(int x, int y))
//{
//	int x = 3;
//	int y = 5;
//	int ret=pf(x, y);
//	printf("%d\n", ret);
//
//}
// int main()
//{
//	call(Add);
//	return 0;
//}


//////函数指针数组
//int add(int x, int y)
//{
//	return x + y;
//}
//int sub(int x, int y)
//{
//	return x - y;
//}
//int main()
//{
//	int(*pf[])(int ,int ) = {NULL, add,sub};
//	for (int i = 1; i <=2; i++)
//	{
//		int ret= pf[i](6, 2);
//		printf("%d ", ret);
//	}
//	return 0;
//}
//


//回调函数
//void meau()
//{
//	printf("*******************\n");
//	printf("****1.add 2.sub****\n");
//	printf("****3.mul 4.DIV****\n");
//	printf("****0.exit*********\n");
//	printf("*******************\n");
//}
//
//int add(int x, int y)
//{
//	return x + y;
//}
//int sub(int x, int y)
//{
//	return x - y;
//}
//int mul(int x, int y)
//{
//	return x * y;
//}
//int DIV(int x, int y)
//{
//	return x / y;
//}
//void cacl(int (*pf)(int, int))
//{
//	int x = 0;
//	int y = 0;
//	printf("输入二个操作符\n");
//	scanf("%d %d", &x, &y);
//	int ret = 0;
//	ret = (pf)(x, y);
//	printf("%d\n", ret);
//}
//int main()
//{
//	int input = 0;
//	do
//	{
//		meau();
//		scanf("%d", &input);
//		switch (input)
//		{
//		case 1:
//			cacl(add);
//			break;
//		case 0:
//			printf("退出游戏\n");
//			break;
//		case 2:
//			cacl(sub);
//			break;
//		case 3:
//			cacl(mul);
//			break;
//		case 4:
//			cacl(DIV);
//			break;
//		default:
//			printf("输入错误，请重新输入\n");
//		}
//
//	} while (input);
//	return 0;
//}







//void meau()
//{
//	printf("*******************\n");
//	printf("****1.add 2.sub****\n");
//	printf("****3.mul 4.DIV****\n");
//	printf("****0.exit*********\n");
//	printf("*******************\n");
//}
//
//int add(int x, int y)
//{
//	return x + y;
//}
//int sub(int x, int y)
//{
//	return x - y;
//}
//int mul(int x, int y)
//{
//	return x * y;
//}
//int DIV(int x, int y)
//{
//	return x / y;
//}
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;
//	int red = 0;
//	int (*parr[5])(int, int) = { NULL,add,sub,mul,DIV };
//	do
//	{
//		meau();
//		printf("请选择\n");
//		scanf("%d", &input);
//		if (input == 0)
//		{
//			printf("退出\n");
//		}
//		else if (input >= 1 && input <= 4)
//
//		{
//			printf("请输入二个操作数\n");
//			scanf("%d %d", &x, &y);
//			red = parr[input](x, y);
//			printf("%d\n", red);
//		}
//		else
//		{
//			printf("选择错误\n");
//		}
//
//	} while (input);
//	return 0;
//}
//
//
////
//
////快排
//int cmp_int(const void* e1, const void* e2)
//{
//	return *(int*)(e2)-*(int*)(e1);
//}
//int main()
//{
//	int arr[] = { 2,43,4344,565,232,1 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	qsort(arr, sz, sizeof(arr[0]), cmp_int);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}


//结构体排序
//struct stu
//{
//	int age;
//	char name[20];
//
//};
//int cmp_stu(const void* e1, const void* e2)
//{
//	return (((struct stu*)e2)->age - ((struct stu*)e1)->age);
//}
//int main()
//{
//   struct stu u[] = {{13,"wds"},{23,"fd"},{345,"sds"}};
//   int sz = sizeof(u) / sizeof(u[0]);
//   qsort(u, sz, sizeof(u[0]), cmp_stu);
//   for (int i = 0; i < 3; i++)
//   {
//	   printf("%d ", u[i].age);
//   }
//    return 0;
//}

//struct stu
//{
//	int age;
//	char name[20];
//
//};
//int cmp_stu_name(const void* e1, const void* e2)
//{
//	return strcmp(((struct stu*)e2)->name,((struct stu*)e1)->name);
//}
//int main()
//{
//	struct stu u[] = { {13,"wds"},{23,"fd"},{345,"sds"} };
//	int sz = sizeof(u) / sizeof(u[0]);
//	qsort(u, sz, sizeof(u[0]), cmp_stu_name);
//	for (int i = 0; i < 3; i++)
//	{
//		printf("%s ", u[i].name);
//	}
//	return 0;
//}

//模拟qsort函数
//void swap(char* buf1,char* buf2,int width)
//{
//	for (int i = 0; i < width; i++)
//	{
//		char tep =*buf1;
//		*buf1 = *buf2;
//		*buf2 = tep;
//		buf1++;
//		buf2++;
//	}
//}
//int cmp_int(void* e1, void* e2)
//{
//	return *(int*)e1 - *(int*)e2;
//}
//void bubble_sort(void* base, int sz, int  width, int (*cmp)(const void* e1, const void* e2))
//{
//	for (int i = 0; i < sz - 1; i++)
//	{
//		for (int j = 0; j < sz - 1 - i; j++)
//		{
//			//是否cmp>0，>0就交换
//			if (cmp(((char*)base + j * width), (char*)base + (j + 1) * width) > 0)
//			{
//				//交换
//				swap(((char*)base + j * width), (char*)base + (j + 1) * width, width);
//			}
//		}
//	}
//}
//int main()
//{
//	int arr[10] = { 2,3,234,652,6,245,672,72,665,22 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}


//结构体排序

//struct stu
//{
//	int age;
//	char name[20];
//};
//int cmp_struct_age(void* e1, void* e2)
//{
//	return *(int*)e1 - *(int*)e2;
//}
//void swap(char* buf1,char* buf2,int width)
//{
//	for (int i = 0; i < width; i++)
//	{
//		char tep =*buf1;
//		*buf1 = *buf2;
//		*buf2 = tep;
//		buf1++;
//		buf2++;
//	}
//}
//void bubble_sort(void* base, int sz, int  width, int (*cmp)(const void* e1, const void* e2))
//{
//	for (int i = 0; i < sz - 1; i++)
//	{
//		for (int j = 0; j < sz - 1 - i; j++)
//		{
//			//是否cmp>0，>0就交换
//			if (cmp(((char*)base + j * width), (char*)base + (j + 1) * width) > 0)
//			{
//				//交换
//				swap(((char*)base + j * width), (char*)base + (j + 1) * width, width);
//			}
//		}
//	}
//}
//int main()
//{
//	struct stu arr[] = { {13,"sads"},{23,"tfgt"} };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	bubble_sort(arr, sz, sizeof(arr[0]), cmp_struct_age);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i].age);
//	}
//	return 0;
//}

//struct stu
//{
//	int age;
//	char name[20];
//};
//int cmp_struct_name(void* e1, void* e2)
//{
//	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
//}
//void swap(char* buf1, char* buf2, int width)
//{
//	for (int i = 0; i < width; i++)
//	{
//		char tep = *buf1;
//		*buf1 = *buf2;
//		*buf2 = tep;
//		buf1++;
//		buf2++;
//	}
//}
//void bubble_sort(void* base, int sz, int  width, int (*cmp)(const void* e1, const void* e2))
//{
//	for (int i = 0; i < sz - 1; i++)
//	{
//		for (int j = 0; j < sz - 1 - i; j++)
//		{
//			//是否cmp>0，>0就交换
//			if (cmp(((char*)base + j * width), (char*)base + (j + 1) * width) > 0)
//			{
//				//交换
//				swap(((char*)base + j * width), (char*)base + (j + 1) * width, width);
//			}
//		}
//	}
//}
//int main()
//{
//	struct stu arr[] = { {13,"sads"},{23,"tfgt"} };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	bubble_sort(arr, sz, sizeof(arr[0]), cmp_struct_name);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%s ", arr[i].name);
//	}
//	return 0;
////}
//int main()
//{
//	char arr[] = "abc";
//	printf("%d\n", sizeof(arr));
//	return 0;
//}	

//
//int main()
//{
//	char* a[] = { "work","at","swdw" };
//	char** p = a;
//	p++;
//	printf("%s", *p);
//	return 0;
//}



//
//int main()
//{
//	char s1[] = { 0 };
//	gets(s1);//computer
//	int m = 0;//2
//	int n = 0;//3
//	char s2 = { 0 };
//	scanf("%d %d", &m, &n);
//	char str = 0;//结束地址
//	
//	if (n && *s1 != '\0');
//		{
//			s2 = s1 + m;
//		    str = s2 + n;
//		}
//
//
//	return 0;
////}
#include <ctype.h>
//int main()
//{
//	char c = 0;
//	while (~scanf("%c",&c))
//	{
//		if (islower(c))
//			printf("小写\n");
//		else if (isupper(c))
//	
//			printf("大写\n");
//
//	}
//	return 0;
//}

//#include <stdio.h>
//#include <ctype.h> // 引入头文件以使用 islower 和 toupper 等函数
//
//int main()6
//{
//    char str[100] = { 0 };
//    int i = 0;
//    while (scanf("%c", &str[i])!=EOF) // 修改 scanf 的用法，并添加结束输入的条件
//    {
//        if (islower(str[i]))
//        {
//            str[i] = toupper(str[i]);
//        }
//        else if (isupper(str[i]))
//        {
//            str[i] = tolower(str[i]);
//        }
//        printf("%c", str[i]); // 修改 printf 的用法，因为你是打印字符而不是字符串
//        i++;
//    }
//    return 0;
//}
 


//判断是否为字符函数且大写转小写，小写转大写

//int main()
//{
//	char c = 0;
//	while (~scanf("%c", &c))
//	{
//		if (islower(c))
//		{
//			c = toupper(c);
//		}
//		else if (isupper(c))
//		{
//			c = tolower(c);
//		}
//		printf("%c", c);
//	}
//	return 0;
//}


//strlen函数的模拟实现
//方法1 指针-指针
//int my_strlen(char* s1)
//{
//	char* start = s1;
//	while (*s1)
//	{
//		s1++;
//	}
//	return s1 - start;
//}
//int main()
//{
//	char str[] = "abcdef";
//	int  len = my_strlen(str);
//	printf("%d\n", len);
//	return 0;
//}
//
////方法2 递归
//
//int my_strlen(char *s1)
//{
//	if (*s1 == '\0')
//		return 0;
//	else
//		return 1 + my_strlen(s1 + 1);
//
//}
//int main()
//{
//	char str[] = "abcdef";
//	int  len = my_strlen(str);
//	printf("%d\n", len);
//	return 0;
//}


// 模拟实现strcpy
//char* my_strlen(char* s1, char* s2)
//{
//	char* strat = s1;
//	while (*s1++ = *s2++)
//	{
//		;
//	}
//	return strat;
//}
//int main()
//{
//	char str1[20] = { 0 };
//	char str2[] = "abcdef";
//	my_strlen(str1,str2);
//	printf("%s ",str1);
//	return 0;
//}


//模拟实现strcmp
//int my_strcmp(char* s1, char* s2)
//{
//	while (*s1 == *s2)
//	{
//		if (*s1 == '\0')
//		{
//			return  0;
//		}
//		s1++;
//		s2++;
//	}
//	return *s1 - *s2;
//}
//int main()
//{
//	char arr1[] = "abc";
//	char arr2[] = "bq";
//	int len=my_strcmp(arr1, arr2);
//	if (len==1)
//	{
//		printf("大于\n");
//	}
//	else if (len == 0)
//	{
//		printf("等于\n");
//
//	}
//	else
//		printf("小于\n");
//
//	return 0;
//} 
//
////int main()
////{
////	char str1[20] = "xxxxx\0xxxxxxx";
////	char str2[] = "abcdef";
////	strcat(str1,str2);
////	printf("%s ",str1);
////	return 0;
////}

//模拟实现strstr
//char* my_strstr(char* str1, char* str2)
//{
//	char* cur = str1;
//	char* s1 = NULL;
//	char* s2 = NULL;
//	if (*str2==NULL)
//		return str1;
//	while (*cur)
//	{
//
//		s1 = cur;
//		s2 = str2;
//		while (*s1 == *s2 && *s1 && *s2)
//		{
//			s1++;
//			s2++;
//		}
//		if (*s2 == '\0')
//		{
//			return cur;
//		}
//		cur++;
//	}
//	return NULL;
//}
//int main()
//{
//	char str1[] = "abbbcde";
//	char str2[] = "bc";
//	char *tep=my_strstr(str1, str2);
//	printf("%s\n", tep);
//	return 0;
//}

//#include <stdio.h>
//#include <string.h>
//
//int main() {
//    char str1[100]; // 假设输入的字符串不超过99个字符
//    char str2[100]; // 提取的子字符串存放位置
//    int m, n;
//
//    // 获取用户输入的字符串
//    printf("请输入一个字符串str1: ");
//    scanf("%99s", str1); // %99s限制最多读取99个字符，防止溢出
//
//    // 获取起始位置和字符数量
//    printf("请输入起始位置m（从1开始计数）: ");
//    scanf("%d", &m);
//    printf("请输入需要提取的字符数量n: ");
//    scanf("%d", &n);
//
//    // 检查m和n的有效性
//    if (m < 1 || m > strlen(str1) || n < 1 || m + n - 1 > strlen(str1)) {
//        printf("输入的m或n无效。\n");
//        return 1;
//    }
//
//    // 由于C语言中字符串索引是从0开始的，所以m需要减1
//    m = m - 1;
//
//    // 提取子字符串
//    strncpy(str2, str1 + m, n);
//
//    // 确保str2是一个正确终止的字符串
//    str2[n] = '\0';
//
//    // 输出结果
//    printf("提取的子字符串是: %s\n", str2);
//
//    return 0;
////}
//
//
////字符串分割函数strtok
//int main()
//{
//	char arr1[] = "zhangsan&1312.*.23";
//	char arr2[30] = { 0 };
//	strcpy(arr2, arr1);
//	char* etr = "&*.";
//	char* s = NULL;
//	for (s = strtok(arr2, etr); s != NULL; s = strtok(NULL, etr))
//	{
//		printf("%s\n", s);
//   }
//	return 0;
//}    



//字符串函数

//1.判断小写和大写并且小转大，大转小

//int main()
//{
//	char ch = 0;
//	while (~scanf("%c", &ch))
//	{
//		if(islower(ch))
//		{
//			ch = toupper(ch);
//		}
//		else if (isupper(ch))
//		{
//			ch = tolower(ch);
//		}
//		printf("%c", ch);
//	}
//	return 0;
//}


//模拟实现strlen函数
//方法1函数递归
//int my_strlen(char* s1)
//{
//	if (*s1 == '\0')
//		return 0;
//	else
//		return 1 + my_strlen(s1 + 1);
//}
//int main()
//{
//	char str[] = "abcs";
//   int ret=	my_strlen(str);
//   printf("%d\n", ret);
//	return 0;
//}

//方法2 指针-指针
//char* my_strlen(char* s1)
//{
//	char* start = s1;
//	while (*s1)
//	{
//		s1++;
//	}
//	return s1 - start;
//}
//int main()
//{
//	char str[] = "abcs";
//	int ret = my_strlen(str);
//	printf("%d\n", ret);
//	return 0;
//}

////计数器的方法
//int my_strlen(char* s1)
//{
//	int count = 0;
//	while (*s1)
//	{
//		s1++;
//		count++;
//	}
//	return count;
//}
//int main()
//{
//	char str[] = "abcs";
//	int ret = my_strlen(str);
//	printf("%d\n", ret);
//	return 0;
//}

//strcpy函数
//void my_strcpy(char* s1, char* s2)
//{
//	char* tep = s1;
//	while (*s1++ = *s2++)
//	{
//		;
//	}
//	return  tep;
//}
//int main()
//{
//	char str1[20] = { 0 };
//	char str2[] = "asdw";
//	my_strcpy(str1, str2);
//	printf("%s\n", str1);
//	
//	return 0;
//}


//strcat函数
//void my_strcat(char* s1, char* s2)
//{
//	char* tep = s1;
//	while (*s1)
//	{
//		s1++;
//	}
//	while (*s1++ = *s2++)
//	{
//		;
//	}
//	return tep;
//}
//int main()
//{
//	char str1[20] = "hhh";
//	char str2[] = "asdw";
//	my_strcat(str1, str2);
//	printf("%s\n", str1);
//
//	return 0;
//}


//strcmp函数
//int my_strcmp(char* s1, char* s2)
//{
//	while (*s1 == *s2)
//	{
//		if (*s1 == '\0')
//			return 0;
//		s1++;
//		s2++;
//	}
//	return *s1 - *s2;
//}
//int main()
//{
//	char str1[20] = "hhh";
//	char str2[] = "asdw";
//	int ret=my_strcmp(str1, str2);
//	if (ret >0)
//	{
//		printf("大于\n");
//	}
//	else if(ret<0)
//		printf("小于\n");
//	else
//		printf("等于\n");
//	return 0;
//}


////strstr函数
//char* my_strstr(char* str1, char* str2)
//{
//	char* cur = str1;
//	char* s1 = NULL;
//	char* s2 = NULL;
//
//	if (*str2 =='\0')
//		return str1;
//	while (*cur)
//	{
//		s1 = cur;
//		s2 = str2;
//		while (*s1 == *s2 && *s1&& *s2)
//		{
//			s1++;
//			s2++;
//		}
//		if (*s2 == '\0')
//			return cur;
//		cur++;
//	}
//	return NULL;
//}
//int main()
//{
//	char str1[] = "abbbcd";
//	char str2[] = "bcd";
//	char *s1=my_strstr(str1, str2);
//	if (s1 != NULL)
//		printf("%s\n", s1);
//	else
//		printf("没有\n");
////	
////	return 0;
//}


//20.试编程实现：将 s 所指字符串中除下标为偶数同时 ASCII 码值也为偶数的字符外，其余的全部删除;
//字符串中剩余字符所形成的新串放在新的数组中。
//例如，若 s 所指字符串中的内容为"ABCDEFG123456"，其中字符 A 的 ASCII 码值为奇数，因此应当删
//除; 字符 B 的 ASCII 码值为偶数，但在数组中的下标为奇数，因此也应当删除; 字符 2 的 ASCII 码值为偶
//数，在数组中的下标也为偶数，因此不应当册除，其他依此类推。最后新的数组中的内容应是"246"。


//
//int main()
//{
//	char str1[] = "ABCDEFG123456";
//	//A(65,0) B(66,1) C(67,2) D(68,3)
//	char str2[100] = { 0 };
//	int len = strlen(str1);
//	int j = 0;
//	for (int i = 0; i < len; i++)
//	{
//		if ((i % 2 == 0) && (str1[i] % 2 == 0))
//		{
//			str2[j++] = str1[i];
//		}
//	}
//	str2[j] = '\0';
//
//		printf("%s\n", str2);
//	return 0;
//}
////	
////}‘

//
////19.试编程实现：判断 s 所指字符串中的字母是否由连续递增字母序列(组成字符串长度大于等于 2)。
////例如字符串∶uvwxyz 满足要求; 而字符串∶ uvxwyz 不满足要求
//
//int str_gl(char* s, int len)
//{
//	if (len < 2)
//	return 0;
//		for (int i = 0; i < len - 1; i++)
//		{
//			if (s[i + 1] - s[i] != 1)
//			{
//				return 0;
//			}
//		}
//		return 1;
//}
//int main()
//{
//	char str[100] = { 0 };
//	gets(str);
//	int len = strlen(str);
//	int ret=str_gl(str, len);
//	if (ret == 1)
//		printf("满足\n");
//	else
//		printf("不满足\n");
//
//	return 0;
////}
////
////21.试编程实现：一包含 5 名自定义学生信息（姓名，学号，三门课程成绩，平均分）的结构体数组，
////通过自定义函数 Ave（）求得每位学生的平均成绩，并在主函数中按平均分从高到低依次输出学生信
////息。
//
//struct stu
//{
//	char name[20];
//	float avg;
//	char ID[20];
//	float cj1;
//	float cj2;
//	float cj3;
//
//
//}cj[5] 
//;
//	
//int cmp_struct(const void* e1, const void* e2)
//{
//	return *(float*)e1 - *(float*)e2;
//}
//void Ave()
//{
//	
//	for (int i = 0; i < 5; i++)
//	{
//		cj[i].avg = (cj[i].cj1 + cj[i].cj2 + cj[i].cj3) / 3;
//
//	}
//	qsort(cj, 5, sizeof(cj[0]), cmp_struct);
//	for (int i = 0; i < 5; i++)
//	{
//		printf("%.2f\n", cj[i].avg);
//
//	}
//
//}
//int main()
//{
//	cj[0].cj1 = 80;
//	cj[0].cj2 = 100;
//	cj[0].cj3 = 80;
//	cj[1].cj1 = 100;
//	cj[1].cj2 = 100;
//	cj[1].cj3 = 90;
//	cj[2].cj1 = 90;
//	cj[2].cj2 = 80;
//	cj[2].cj3 = 70;
//	cj[3].cj1 = 60;
//	cj[3].cj2 = 80;
//	cj[3].cj3 = 40;
//	cj[4].cj1 = 30;
//	cj[4].cj2 = 80;
//	cj[4].cj3 = 80;
//	Ave(cj);
//
//}a75

	


// 简单版的水仙花数 //三位数
//int xz_num(int i)
//{
//	int count = 0;
//	int a = i % 10;//1234   //4
//	int b = i / 10 % 10;//3
//	int c = i / 100 % 10;//2
//	int d = i / 1000;//1
//	if (i == pow(a, 4) + pow(b, 4) + pow(c, 4) + pow(d, 4))
//	{
//		count++;
//		return count;
//	}
//	else
//		return 0;
//}
//int main()
//{
//	int i = 0;
//	int n = 0;
//	int relust[10000] = { 0 };
//	int ret = 0;
//	for (i = 1000; i < 10000; i++)
//		
//	{
//		 ret = xz_num(i);
//		if (ret)
//		{
//			relust[n] = i;
//			n++;
//		}
//	}
//	
//	for (i = 0; i < ret; i++)
//	{
//		printf("%d ", relust[i]);
//	}
//	return 0;
//}

////19.试编程实现：判断 s 所指字符串中的字母是否由连续递增字母序列(组成字符串长度大于等于 2)。
////例如字符串∶uvwxyz 满足要求; 而字符串∶ uvxwyz 不满足要求
//int tz_str(char* s)
//{
//	int len = strlen(s);
//	if (len < 2)
//		return 0;
//	int j = 0;
//	for (j = 0; j < len - 1; j++)
//	{
//		if (s[j + 1] - s[j] != 1)
//			return 0;
//	}
//	return 1;
//}
//int main()
//{
//	char str1[100] = { 0 };
//	while (gets(str1) != EOF)
//	{
//		int ret=tz_str(str1);
//		if (ret == 1)
//			printf("满足\n");
//		else
//			printf("不满足\n");
//
//	}
//	return 0;
//}\



//20.试编程实现：将 s 所指字符串中除下标为偶数同时 ASCII 码值也为偶数的字符外，其余的全部删除;
//字符串中剩余字符所形成的新串放在新的数组中。
//例如，若 s 所指字符串中的内容为"ABCDEFG123456"，其中字符 A 的 ASCII 码值为奇数，因此应当删
//除; 字符 B 的 ASCII 码值为偶数，但在数组中的下标为奇数，因此也应当删除; 字符 2 的 ASCII 码值为偶
//数，在数组中的下标也为偶数，因此不应当册除，其他依此类推。最后新的数组中的内容应是"246"
//void gl_str(char* s)
//{
//	int len = strlen(s);
//	char str2[100] = { 0 };
//	int j = 0;
//	for (int i = 0; i < len; i++)
//	{
//		if (i % 2 == 0 && s[i] % 2 == 0)
//		{
//			str2[j++] = s[i];
//		}
//	}
//	s[j] = '\0';
//	printf("%s\n", str2);
//}
//int main()
//{
//	char str1[100] = { 0 };
//	while (gets(str1) != EOF)
//	{
//		gl_str(str1);
//	}
//	return 0;
//}

////
////strtok函数
//int main()
//{
//	char str1[] = "1923232.1&&&&11.***13";
//	char str2[100] = { 0 };
//	strcpy(str2, str1);
//	char* s = ".*&";
//	char* p = NULL;
//	for (p = strtok(str2, s); p != NULL; p = strtok(NULL, s))
//	{
//		printf("%s\n", p);
//	}
//	return 0;
//}


//memcpy
//int main()
//{
//	int arr1[] = { 1,2,34,5 };
//	int arr2[20] = { 0 };
//	memcpy(arr2, arr1, 4 * sizeof(int));
//	for (int i = 0; i < 4; i++)
//	{
//		printf("%d ", arr2[i]);
//	}
//	return 0;
//}
//
////模拟实现memcpy
//void* my_memcpy(void* s1, void* s2, int num)
//{
//	while (num--)
//	{
//		*(char*)s1 = *(char*)s2;
//		s1 = (char*)s1 + 1;
//		s2 = (char*)s2 + 1;
////
////	}
////}
//int main()
//{
//	char arr1[] = "1242\0123";
//	int len = strlen(arr1);
//	char arr2[100] = { 0 };
//	my_memcpy(arr2, arr1,len*sizeof(char) );
//	for (int i = 0; i < len; i++)
//	{
//		printf("%c\n", arr2[i]);
//	}
//	return 0;
//}


//结构体传参
//struct stu
//{
//	int age;
//	char name[20];
//};
//void print1(struct stu hh)
//{
//	printf("%d %s", hh.age, hh.name);
//}
////void print2(struct stu *hh)
////{
////	printf("\n%d %s", hh->age, hh->name);
////}
////int main()
////{
////	struct stu hh = { 12,"sfds" };
////	print1(hh);
////	print2(&hh);
////
////	return 0;
////}
//
//
////int main()
////{
////	int tep = 0;
////	int a[10][10]={0};
////	for (int i = 0; i < 10; i++)
////	{
////		for (int j = 0; j <= i; j++)
////		{
////			if (i == j || j == 0)
////			{
////				a[i][j] = 1;
////			}
////		}
////		for (int j = 0; j <= i; j++)
////		{
////			if (i >= 2 && j >= 1)
////			{
////				a[i][j] = a[i-1][j-1] + a[i-1][j];
////
////			}
////		}
////	}
////	for (int i = 0; i < 10; i++)
////	{
////		for (int j = 0; j <= i; j++)
////		{
////			printf("%d ", a[i][j]);
////		}
////		printf("\n");
////	}
////	return 0;
////}
//
//
////int main()
////{
////	int a, b, c = 0;
////	float x, x1, x2 = 0;
////	scanf("%d %d %d", &a, &b, &c);
////	x = b * b - 4 * a * c;
////	if (x > 0)
////	{
////		x1 = (-b - sqrt(x)) / (2 * a);
////		x2 = (-b + sqrt(x)) / (2 * a);
////		printf("%.2f %.2f\n", x1, x2);
////
////	}
////	else if (x == 0)
////	{
////		x1 =x2= (-b) / (2 * a);
////		printf("%.2f %.2f\n", x1, x2);
////
////	}
////	else
////	{
////		printf("方程无实根\n");
////	}
////
////	return 0;
////}
//char* my_strcat(char* s1, char* s2)
//{
//	char* strat = s1;
//	while (*s1)
//	{
//		s1++;
//	}
//	while (*s1++ = *s2++)
//	{
//		;
//	}
//	return strat;
//}
//int main()
//{
//	char s1[10] = { "abc" };
//	char s2[4] = { "def" };
//	char* ret = my_strcat(s1, s2);
//	printf("%s\n", ret);
//	return 0;
//}


////计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值，打印出结果
//int main()
//{
//	int ret = 1;
//	double sum = 0;
//	for (int i = 1; i <= 100; i++)
//	{
//		sum += (1.0) / i*ret; //1. 1  2. 1/2
//		ret = -ret;
//	}
//	printf("%.2lf\n", sum);
//	return 0;
//}
////
////打印1000年到2000年之间的闰年
//
//int main()
//{
//	for (int i = 1000; i <= 2000; i++)
//	{
//		if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0)
//		{
//			printf("%d ", i);
//		}
//	}
//	return 0;
//}


//编写程序数一下 1到 100 的所有整数中出现多少个数字9

////int main()
////{
////	int count = 0;
////	for (int i = 1; i <= 100; i++)
////	{
////		if (i / 10 == 9) 
////			count++;
////		if (i % 10 == 9)
////			count++;
////
////	}
////	printf("%d\n", count);
////	return 0;
////}


//给定两个数，求这两个数的最大公约数

//例如：
//
//输入：20 40
//
//输出：20
//
//
//
//int main()
//{
//	int a, b, c = 0;
//	scanf("%d %d", &a, &b);
//	c = a % b;
//	while (c != 0)
//	{
//		a = b;
//		b = c;
//		c = a % b;
//	}
//	printf("%d\n", b);
//	return 0;
//}


// X图案
//int main()
//{
//	int n = 0;
//	while (~scanf("%d", &n))
//	{
//		for (int i = 0; i < n; i++)
//		{
//		
//			for (int j = 0; j < n; j++)
//			{
//				if (i == j || i + j == n - 1)
//				printf("*");
//				else
//					printf(" ");
//			}
//			
//			printf("\n");
//		}
//	}
//	return 0;
//}


//空心正方形
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	for (int i = 0; i < n; i++)
//	{
//		for (int j = 0; j < n; j++)
//		{
//			if (i == 0 || i == n - 1 || j == 0 || j == n - 1)
//			
//				printf("* ");
//			else
//				printf("  ");
//		
//		}
//		printf("\n");
//	}
//	return 0;
//}